home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 March - Disc 1 / Macworld (1999-03) (Disk 1).dmg / Shareware World / Utilities / Text Processing / Alpha / Tcl / Modes / cMode.tcl < prev    next >
Encoding:
Text File  |  1998-12-19  |  21.1 KB  |  673 lines  |  [TEXT/ALFA]
  1. ## -*-Tcl-*- (install)
  2.  # ###################################################################
  3.  #    Vince's    Additions -    an extension package for Alpha
  4.  # 
  5.  #    FILE: "cMode.tcl"
  6.  #                    created: 19/4/96 {4:53:38 pm}    
  7.  #                 last update: 19/12/1998 {1:09:18 pm}    
  8.  #    Author:    Vince Darley
  9.  #    E-mail:    <darley@fas.harvard.edu>
  10.  #      mail:    Division of    Applied    Sciences, Harvard University
  11.  #            Oxford Street, Cambridge MA    02138, USA
  12.  #       www:    <http://www.fas.harvard.edu/~darley/>
  13.  #    
  14.  # ###################################################################
  15.  ##
  16.  
  17. alpha::mode C 1.2.2 dummyC { *.r } \
  18.   {electricReturn electricBraces electricSemicolon}
  19. alpha::mode C++ 1.2.2 dummyC++ \
  20.   {*.H *.c *.h *.cc *.cp *.cpp *.CPP *.C *.pch *.pch++ *.icc *.exp} \
  21.   {electricReturn electricBraces electricSemicolon}
  22.  
  23. # not really sure this is required any more
  24. # the CW menu registers are proc to call cw IDE.
  25. hook::register saveHook modified "C" "C++"
  26.  
  27. proc dummyC {} {}
  28. proc dummyC++ {} {}
  29.  
  30. newPref f elecColon {1} C
  31. newPref v leftFillColumn {3} C
  32. newPref v prefixString {//} C
  33. newPref f elecElse {1} C
  34. newPref f wordWrap {0} C
  35. newPref v funcExpr {^[^ \t\(#\r/@].*\(.*\)$} C
  36. newPref v parseExpr {\b([_:\w]+)\s*\(} C
  37. newPref v wordBreak {[_\w]+} C
  38. newPref v wordBreakPreface {[^_\w]} C
  39. newPref f autoMark 0 C
  40. newPref v stringColor green C
  41. newPref v commentColor red C
  42. newPref v funcColor yellow C
  43. newPref v keywordColor blue C
  44. newPref v CWCompSig CWIE C
  45. newPref v CWDbgSig MWDB C
  46. newPref v SymCompSig KAHL C
  47. newPref v SymDbgSig {◊LSD} C
  48. newPref f includeMenu {1} C
  49. newPref f launchIDEifRequired {1} C
  50. newPref v sourceSuffices { .c } C
  51. newPref v headerSuffices { .h } C
  52. newPref v indentComments "code 0" C
  53. newPref v indentMacros "fixed 0" C
  54. newPref v IDE 0 C "" [list "CodeWarrior" "Symantec" "none"] index
  55. newPref f useFasterButWorseIndentation 0 C
  56. set C::commentRegexp    {/\*(([^*]/)|[^*]|\r)*\*/}
  57. set cPreRegexp        {^\#[\t ]*[a-z]*}
  58. set    cKeyWords    {
  59.     void break register short enum extern int for if while struct static long continue
  60.     switch case char unsigned double float return else default goto do pascal Boolean
  61.     typedef volatile union auto sizeof size_t
  62. }
  63. if {[info exists Cwords]} {set cKeyWords [concat $cKeyWords $Cwords]}
  64. regModeKeywords -e {//} -b {/*} {*/} -c $CmodeVars(commentColor) -f $CmodeVars(funcColor) -k $CmodeVars(keywordColor) -s $CmodeVars(stringColor) -m {#} C $cKeyWords
  65.  
  66. #================================================================================
  67.  
  68. newPref f elecColon {1} C++
  69. newPref v leftFillColumn {3} C++
  70. newPref v prefixString {//} C++
  71. newPref v wordBreak {[\w_]+} C++
  72. newPref v wordBreakPreface {[^_\w]} C++
  73. newPref f elecElse {1} C++
  74. newPref f wordWrap {0} C++
  75. newPref v funcExpr {^([^ \t\(#\r/@].*[ \t]+)?\*?([A-Za-z0-9~_]+(<[^>]*>)?::[-A-Za-z0-9~_+= <>\|\*/]+|[A-Za-z0-9~_]+)[ \t\r]*\(} C++
  76. newPref v parseExpr {\b([_:\w]+)\s*\(} C++
  77. newPref f autoMark 0 C++
  78. newPref v stringColor green C++
  79. newPref v commentColor red C++
  80. newPref v keywordColor blue C++
  81. newPref v funcColor yellow C++
  82. newPref v CWCompSig CWIE C++
  83. newPref v CWDbgSig MWDB C++
  84. newPref v SymCompSig KAHL C++
  85. newPref v SymDbgSig {◊LSD} C++
  86. newPref f includeMenu {1} C++
  87. newPref f launchIDEifRequired {1} C++
  88. newPref v sourceSuffices { .cc .cp .cpp .c .icc .C } C++
  89. newPref v headerSuffices { .h .hh } C++
  90. # These three are pairs:
  91. newPref v indentComments "code 0" C++ "" indentationTypes varitem
  92. newPref v indentC++Comments "code 0" C++ "" indentationTypes varitem
  93. newPref v indentMacros "fixed 0" C++ "" indentationTypes varitem
  94. newPref v IDE 0 C++ "" [list "CodeWarrior" "Symantec" "none"] index
  95. newPref f useFasterButWorseIndentation 0 C++
  96. newPref folder universalHeadersFolder "" C++
  97.  
  98. proc C++::openUniversalHeader {} {
  99.     global universalHeadersFolder tabSize
  100.     set filename [prompt::statusLineComplete "Open which header" \
  101.       [list file::completeFromDir $universalHeadersFolder] -nocache -tryuppercase]
  102.     set old $tabSize
  103.     set tabSize 4
  104.     file::openQuietly [file join $universalHeadersFolder $filename]
  105.     set tabSize $old
  106. }
  107.  
  108. Bind 'q' <o> C++::openUniversalHeader C++
  109.  
  110. set C++::commentRegexp    {/\*(([^*]/)|[^*]|\r)*\*/}
  111.  
  112. set {c++KeyWords} {
  113.     new delete explicit class friend protected private public template try 
  114.     catch throw operator const mutable virtual asm inline this and and_eq 
  115.     bitand bitor compl not or or_eq xor xor_eq not_eq wchar_t bool true 
  116.     false bool inline mutable static_cast dynamic_cast reinterpret_cast 
  117.     typeid using namespace inherited
  118. }
  119. if {[info exists {C++words}]} {
  120.     set {c++KeyWords} [concat ${c++KeyWords} ${C++words} $cKeyWords]
  121. } else {
  122.     set {c++KeyWords} [concat ${c++KeyWords} $cKeyWords]
  123. }
  124.  
  125. regModeKeywords -e {//} -b {/*} {*/} -c [set C++modeVars(commentColor)] -f [set C++modeVars(funcColor)] -k [set C++modeVars(keywordColor)] -s [set C++modeVars(stringColor)] -m {#} {C++} ${c++KeyWords}
  126. unset cKeyWords
  127. unset {c++KeyWords}
  128.  
  129. proc C++::DblClick {from to shift option control} {    
  130.     if {[regexp {#include.*("|<)(.*)("|>)} [getText [lineStart [getPos]] [nextLineStart [getPos]]] d1 d1 inc]} {
  131.         return [file::tryAndOpen $inc]
  132.     }
  133.  
  134.     select $from $to
  135.     set text [getSelect]
  136.     
  137.     global tagFile
  138.     set lines [grep "^$text'" $tagFile]
  139.     if {[regexp {'(.*)'(.*[^\t])(\t)+∞} $lines dummy one two]} {
  140.         file::openQuietly $one
  141.         set inds [search -s -f 1 -r 0 "$two" [minPos]]
  142.         display [lindex $inds 0]
  143.         eval select $inds
  144.     } else {
  145.         app::launchFore DanR
  146.         AEBuild {'DanR'} DanR {REF } "----" "“$text”"
  147.     }
  148. }
  149.  
  150. proc C++::parseFuncs {} {
  151.     global mode sortFuncsMenu
  152.     global funcExpr parseExpr
  153.     
  154.     set pos [minPos]
  155.     while {[set res [search -s -f 1 -r 1 -i 0 -n $funcExpr $pos]] != ""} {
  156.         if {[regexp $parseExpr [getText [car $res] [cadr $res]] dummy word]} {
  157.             lappend m [list $word [car $res]]
  158.         }
  159.         set pos [cadr $res]
  160.     }
  161.     if $sortFuncsMenu {
  162.         regsub -all "\[\{\}\]" [lsort -ignore $m] "" m
  163.     } else {
  164.         regsub -all "\[\{\}\]" $m "" m
  165.     }    
  166.     set files ""
  167.     foreach f [getIncludeFiles] {
  168.         lappend files $f -1
  169.     }
  170.     return [concat $files [list "(-" 0] $m]
  171. }
  172.  
  173. # for C mode
  174.  
  175. proc C::DblClick {args} { eval C++::DblClick $args }
  176.  
  177. proc C::parseFuncs {} {
  178.     return [C++::parseFuncs]
  179. }
  180.  
  181.  
  182. #############################################################################
  183. #                                                                            #
  184. #    Stuff above    this point has only    minor modifications    from the original    #
  185. #    "cMode.tcl", stuff below is    largely    or totally new.                        #
  186. #                                                                            #
  187. #############################################################################
  188.  
  189. # ◊◊◊◊ File marking ◊◊◊◊ #
  190.  
  191. ## 
  192.  # -------------------------------------------------------------------------
  193.  #     
  194.  # "C++::MarkFile" --
  195.  #    
  196.  #    Improved version which handles templates, operators    etc.
  197.  #    Makes use of the new mark menu in Alpha    6.5 which can handle
  198.  #    more weird characters.  Handles most 'operator =+-*...' functions
  199.  #  for C++
  200.  #  
  201.  #  Better marking of templates recently added.
  202.  # -------------------------------------------------------------------------
  203.  ##
  204. proc C++::MarkFile {} {
  205.     if {[file extension [win::Current]] == ".exp"} { return }
  206.     set pos [minPos]
  207.     set markExpr "^(\[A-Za-z0-9~_\]+\[ \t\n\r\]*\\(|(\[^ \t\(#\n\r/@\*\].*\[ \t\]+\\*?)?(\[A-Za-z0-9~_\]+(<\[^>\]*>)?(::)?\[-A-Za-z0-9~_+= <>\|\\*/\]+|\[A-Za-z0-9~_\]+)\[ \n\t\r\]*\\()\[^(\]"
  208.     while {![catch {search -s -f 1 -r 1 -m 0 -i 0 "$markExpr" $pos} res]} {
  209.     if [catch {search -s -f 0 -r 1 -m 0 -l [lindex $res 0] -i 0 \
  210.       {[ *][a-zA-Z]} [set pos [pos::math [lindex $res 1] + 1]]} start] {
  211.         set start [lindex $res 0]
  212.         if {[regexp "^\[A-Za-z0-9~_\]+\[ \t\r\n\]*\\(" \
  213.           [getText $start [nextLineStart $start]] thistext]} {
  214.         # nothing
  215.         } else {
  216.         continue
  217.         }
  218.         
  219.     } else {
  220.         set start [lindex $start 0]
  221.         set thistext [getText $start $pos]
  222.     }
  223.     #regexp doesn't like carriage returns or tabs
  224.     #if the open paren was the last character on the line the selected text 
  225.     #included the last carriage return as well
  226.     #trim this off now that it is changed into a space
  227.     regsub -all "\[\r\n\t\]" [string trimright $thistext] " " thistext
  228.     if {[regexp "(\[A-Za-z0-9~_\]+(<\[^>\]*>)?(::)?\[-A-Za-z0-9~_+= <>\|\*/\]+|\[A-Za-z0-9~_\]+)\[ \t\]*\\(" $thistext dummy word]} {
  229.         if { [string first "::" $word] != -1 } {
  230.         regsub {(<\w+>)?::} $word " " it
  231.         set l [lindex $it 0]
  232.         if { $l == [lindex $it 1] } {
  233.             set word "Construct '$l'"
  234.         } elseif { "~$l" == [lindex $it 1] } {
  235.             set word "Destruct '$l'"
  236.         }
  237.         }
  238.         set inds($word) [lineStart [expr $start - 1]]
  239.     }
  240.     }
  241.     if {[info exists inds]} {
  242.     foreach f [lsort -ignore [array names inds]] {
  243.         set next [nextLineStart $inds($f)]
  244.         set it $f
  245.         if {[string length $it] > 57} { set it "[string range $it 0 53]..." }
  246.         setNamedMark "${it}" "$inds($f)" $next $next
  247.     }
  248.     }
  249. }
  250.  
  251. proc C::MarkFile {} { C++::MarkFile }
  252.  
  253.  
  254. # ◊◊◊◊ Indentation routines ◊◊◊◊ #
  255.  
  256. proc C::indentLine {} {C++::indentLine}
  257.  
  258.  ## 
  259.   # -------------------------------------------------------------------------
  260.   #     
  261.   #    "C++indentLine" --
  262.   #    
  263.   #     More sophisticated    version    of Pete's.    Handles    things like    '(...)'
  264.   #     expressions split over    multiple lines,    if/elseif/else both    with and
  265.   #     without curly braces, multiple    line stream    manipulation with '<<'
  266.   #     or    '>>', C and C++ style comments, ...  Assumes indentation is '4'
  267.   #   but any tab-size may be used.
  268.   #     
  269.   #     Current bugs: multi-line ',' separated lists are poorly indented.
  270.   #
  271.   #  Problems:
  272.   #   matchIt's limit doesn't seem to work, so if there is no match and we're
  273.   #   in a large file, we wait up to seconds sometimes.  Alpha bug.
  274.   #           
  275.   #     Currently checking whether we're in a /*...*/ comment is quite
  276.   #   time consuming.  It would be nice if Alpha supplied a hook to do
  277.   #   this for us.
  278.   #   
  279.   #    Results:
  280.   #     Indents the current line correctly    ;-)    for    C, C++ coding
  281.   #     
  282.   # --Version--Author------------------Changes-------------------------------  
  283.   #      1.0      Pete Keleher              original
  284.   #    2.0     <darley@fas.harvard.edu> updated as described above.
  285.   #    2.1     <darley@fas.harvard.edu> faster, better, uses positions not strings
  286.   #    2.2     <darley@fas.harvard.edu> uses 'correctIndentation' sub proc
  287.   # -------------------------------------------------------------------------
  288.   ##
  289. proc C++::indentLine {} {
  290.     global gotoEol
  291.     set gotoEol 0
  292.     
  293.     # preliminaries
  294.     set beg [lineStart [getPos]]
  295.     # are we in a C comment /*...*/ if so indent specially and return
  296.     # we really need to work out how to put this in 'correctIndentation'
  297.     if {![catch {C_inCComment $beg} comment]} {
  298.     set fChar [search -s -f 1 -r 1 "\[^ \t\r\n\]" $beg]
  299.     if { [lookAt [lindex $fChar 0]] == "*" } {
  300.         return [eval C_indentCommentLine [list $beg] $comment]
  301.     }
  302.     }
  303.     set text [getText $beg [nextLineStart $beg]]
  304.     if {[regexp "^\[ \t\]*" $text white]} {
  305.     set len [string length $white]
  306.     set rest [string range $text $len end]
  307.     } else {
  308.     set white ""
  309.     set rest ""
  310.     set len 0
  311.     }
  312.     # get indentation level    
  313.     set lwhite [text::indentOf [C++::correctIndentation [getPos] [string trim $rest]]]
  314.     if {$white != $lwhite} {
  315.     replaceText $beg [pos::math $beg + $len] $lwhite
  316.     }
  317.     if $gotoEol {
  318.     goto [pos::math [nextLineStart $beg] - 1]
  319.     } else {
  320.     goto [pos::math $beg + [string length $lwhite]] 
  321.     }
  322.     
  323. }
  324. proc C::correctIndentation {args} {eval C++::correctIndentation $args}
  325. ## 
  326.  # -------------------------------------------------------------------------
  327.  # 
  328.  # "C++::correctIndentation" --
  329.  # 
  330.  #  Known bugs:
  331.  #  
  332.  #  Lines which contain a URL with :// embedded tend to be considered
  333.  #  a ':' followed by a comment, and are indented as if they were
  334.  #  part of a 'case://comment' statement which is wrong.
  335.  # -------------------------------------------------------------------------
  336.  ##
  337. proc C++::correctIndentation {pos {nextword ""}} {
  338.     global gotoEol
  339.     # preliminaries
  340.     set beg [lineStart $pos]
  341.     set nextCh [string range $nextword 0 3]
  342.     set nextC [string index $nextCh 0]
  343.     set nextP [string range $nextCh 0 1]
  344.     # check for forced indentation of C, C++ comments and '#' macros
  345.     set ind "code 0"
  346.     switch -- $nextC {
  347.     "\#" {
  348.         global indentMacros
  349.         set ignore_trailers ""
  350.         set ind $indentMacros
  351.     }
  352.     "/" {
  353.         global indentComments indentC++Comments
  354.         set ignore_trailers ""
  355.         if {$nextP == "/*"} {set ind $indentComments}
  356.         if {$nextP == "//"} {set ind ${indentC++Comments}}
  357.     }
  358.     }
  359.     if {[lindex $ind 0] == "fixed" } {
  360.     # force indentation to given level
  361.     return [lindex $ind 1]
  362.     }
  363.     
  364.     # (1) first we get the indent of the last line:
  365.     # this may involve looking back a fair way
  366.     set lst [C_prevCodeIndent [pos::math $beg - 1]]
  367.     
  368.     if {[pos::compare [set pstart [lindex $lst 0]] == [minPos]]} {
  369.     return 0
  370.     }
  371.     set lwhite [posX [pos::math [lindex $lst 1] - 1]]    
  372.     # have we just finished an if-elseif-else with no '{}'?
  373.     if {$nextCh == "else"} {set iselse 1} else { set iselse 0}
  374.     if ![C_isLineNBI $pstart] {
  375.     incr lwhite [C_recurseNoBraceIndent $pstart 0 $iselse]
  376.     }
  377.     if { [set multi [C_isLineMulti $pstart]] != "-1" } {
  378.     set lwhite $multi
  379.     }
  380.     
  381.     # (2) now we indent this line accordingly
  382.     
  383.     set pbeg [prevLineStart $beg]
  384.     set backpos [nextLineStart [lindex $lst 0]]
  385.     # is there a comment at the end of the line? if so scan back to the character we want
  386.     if ![catch {search -s -f 0 -r 1 -l $pbeg "//\[^\r\n\]*\[\n\r\]" $beg} compos] {
  387.     set compos [lindex $compos 0]
  388.     if {[pos::compare $compos > $pbeg]} {
  389.         set backpos [pos::math $compos + 1]
  390.     }    
  391.     }
  392.     global indentationAmount
  393.     if {[pos::compare [set backpos [pos::math $backpos - 2]] > [minPos]]} {
  394.     set lst [search -s -f 0 -r 1 -m 0 "\[^ \t\r\n\]" $backpos]
  395.     switch -- [lookAt [lindex $lst 0]] {
  396.         "\{" {
  397.         incr lwhite $indentationAmount
  398.         } 
  399.         ":" {
  400.         incr lwhite [expr $indentationAmount /2]
  401.         } 
  402.         "\)" {
  403.         # see if we're in a if-elseif-else with no '{}' and indent
  404.         if [C_isLineNBI $pstart] {
  405.             incr lwhite $indentationAmount
  406.         }
  407.         }
  408.         "e" {
  409.         if { [getText [pos::math [lindex $lst 0] - 3] \
  410.           [pos::math [lindex $lst 0] + 1]] == "else" } {
  411.             if [C_isLineNBI $pstart] {
  412.             incr lwhite $indentationAmount
  413.             }
  414.         }
  415.         
  416.         }
  417.     }
  418.     }
  419.     
  420.     switch -- $nextC {
  421.     "\}" {
  422.         incr lwhite [expr -$indentationAmount]
  423.     }
  424.     "<" -
  425.     ">" {            
  426.         # indent for '<<' and '>>' in multi-line C++ stream manipulation
  427.         if {$nextP == "<<" || $nextP == ">>"} {
  428.         set strm [search -s -f 1 -r 1 "^\[^${nextC}\]+${nextP}" $pbeg]
  429.         set lwhite [posX [pos::math [lindex $strm 1] - 2]]
  430.         set gotoEol 1
  431.         }
  432.     }
  433.     }
  434.     # Check if we're in a multi-line '(.....)' if so align to start
  435.     global useFasterButWorseIndentation
  436.     if {!$useFasterButWorseIndentation && ![catch {matchIt ")" $beg 200} paren]} {
  437.     set lwhite [posX [pos::math $paren + 1]]
  438.     set gotoEol 1
  439.     }
  440.     
  441.     if {[regexp "^(case\[ \t\].*|\[a-zA-Z\]+):" $nextword] && $lwhite > 3 \
  442.       && ![info exists ignore_trailers]} {
  443.     incr lwhite [expr -$indentationAmount/2]
  444.     }
  445.     # get indentation level    
  446.     return [incr lwhite [lindex $ind 1]]
  447. }
  448.  
  449. ## 
  450.  # -------------------------------------------------------------------------
  451.  #     
  452.  # "recurseNoBraceIndent" --
  453.  #    
  454.  #    Scans back until we    no longer have a 'no brace indent'.    
  455.  #    A 'no brace indent' is    a 'for', 'if' etc which    didn't use
  456.  #    '{ ... }'
  457.  # -------------------------------------------------------------------------
  458.  ##
  459. proc C_recurseNoBraceIndent {pos offset {iselse 0}} {
  460.     set pos [prevLineStart $pos]
  461.     if [C_isLineNBI $pos] {
  462.     if $iselse {
  463.         set p [text::firstNonWsPos $pos]
  464.         set t [getText $p [pos::math $p + 10]]
  465.         if [regexp  "(else\[ \t\]+)?if.*" $t] {
  466.         return [expr $offset -4]
  467.         }
  468.     }
  469.     return [C_recurseNoBraceIndent $pos [incr offset -4] $iselse]
  470.     }
  471.     return $offset
  472.     
  473. }
  474.  
  475. ## 
  476.  # -------------------------------------------------------------------------
  477.  #     
  478.  # "isLineNBI" --
  479.  #    
  480.  #    Tests if the given line is a 'no brace indent'.
  481.  # -------------------------------------------------------------------------
  482.  ##
  483. set C_recNBI "^\[ \t\]*((\}?\[ \t\]*(if|else\[ \t\]+if)|for)\[ \t\]*\\(.*\\)|\}?\[ \t\]*else)\[ \t\]*(//\[^\r\n\]*)?\[ \t\]*$"
  484. proc C_isLineNBI {pos} {
  485.     global C_recNBI
  486.     if {![catch {search -s -f 1 -r 1 -l [pos::math [nextLineStart $pos] + 2] $C_recNBI $pos} ifelse] } {
  487.     if {[pos::compare $pos == [lindex $ifelse 0]]} {
  488.         return 1 
  489.     }
  490.     }
  491.     return 0
  492. }
  493.  
  494. # use 'catch' to call this proc: error = no, otherwise returns st,end pos
  495. proc C_inCComment {pos} {
  496.     set cS [search -s -f 0 -r 0 -l [pos::math $pos - 1000] "/*" $pos]
  497.     set cE [search -s -f 1 -r 0 -l [pos::math $pos + 1000] "*/" [lindex $cS 1]]
  498.     if {[pos::compare $pos >= [lindex $cE 1]] } {
  499.     error "No"
  500.     } else {
  501.     return "[lindex $cS 0] [lindex $cE 1]"
  502.     }
  503. }
  504.  
  505. # look for '<<' and '(...)' multi lines.
  506. proc C_isLineMulti {pos} {
  507.     # look for multi-line '(...)'
  508.     if { ![catch {search -s -f 0 -r 1 -l $pos {\).*$} [nextLineStart $pos]} paren] \
  509.       && [pos::compare [nextLineStart $pos] == [pos::math [lindex $paren 1] + 1 ]] } {
  510.     if {[catch {matchIt ")" [pos::math [lindex $paren 0] - 1] 200} realStart]} {
  511.         return -1
  512.     }
  513.     if {[pos::compare [lineStart $realStart] != [lineStart [lindex $paren 0]]] } {
  514.         set lst [search -s -f 0 -r 1 -i 0 "^\[ \t\]*\[^ \t\r\n\]" $realStart]
  515.         return [posX [pos::math [lindex $lst 1] - 1]]
  516.     }
  517.     }
  518.     # look for multi-line '<<' or '>>'
  519.     set p $pos
  520.     while {![catch {search -s -f 1 -r 1 -l [nextLineStart $p] "^\[ \t\]*(<<|>>)" $p} strm] } {
  521.     set p [prevLineStart $p]
  522.     }
  523.     if { $p != $pos } {
  524.     set lst [search -s -f 1 -r 1 -i 0 "^\[ \t\]*\[^ \t\r\n\]" $p]
  525.     return [posX [pos::math [lindex $lst 1] - 1]]
  526.     }
  527.     
  528.     return -1
  529.     
  530. }
  531.  
  532. ## 
  533.  # -------------------------------------------------------------------------
  534.  #   
  535.  # "C_indentCommentLine" --
  536.  #  
  537.  #  Indents a line within a multi-line /* ... */ comment correctly.
  538.  # -------------------------------------------------------------------------
  539.  ##
  540. proc C_indentCommentLine {beg cS cE} {
  541.     set lwhite [text::minSpaceForm [getText [lineStart $cS] $cS]]
  542.     if {[pos::compare $beg != [lineStart [lindex $cE 0]]] \
  543.       || [text::firstNonWs [pos::math $beg - 1]] == "*" } {
  544.     append lwhite " "    
  545.     }
  546.     
  547.     set text [getText $beg [nextLineStart $beg]]
  548.     regexp "^\[ \t\]*" $text white
  549.     set len [string length $white]
  550.     if {$white != $lwhite} {
  551.     replaceText $beg [pos::math $beg + $len] $lwhite
  552.     }
  553.     goto [pos::math $beg + [expr [string length $lwhite] +1]]
  554. }
  555.  
  556.  
  557. ## 
  558.  # -------------------------------------------------------------------------
  559.  #   
  560.  # "C_prevCodeIndent" --
  561.  #  
  562.  #  Find the indent of the previous line
  563.  #  -  If it's the start of the file, return 0 0 (special case)
  564.  #  else
  565.  #  -  if it's a C++ comment, keep looking backwards (so you can offset
  566.  #     C++ comments if you so desire)
  567.  #  -  if it's a C comment, get the indentation of the '/*' not some
  568.  #     intermediate point.
  569.  # -------------------------------------------------------------------------
  570.  ##
  571. proc C_prevCodeIndent {pos} { 
  572.     if {[pos::compare $pos == [minPos]] \
  573.       || ([catch {search -s -m 0 -f 0 -r 1 -i 0 "^\[ \t\]*\[^ \t\r\n\]" $pos} p]) || $p == "[minPos] [minPos]" } {
  574.     return [list [minPos] [pos::math [minPos] + 1]]
  575.     } else {
  576.     set pp [doubleLookAt [pos::math [lindex $p 1] - 1]]
  577.     if { $pp == "//" } {
  578.         return [C_prevCodeIndent [pos::math [lindex $p 0] - 1]]
  579.     } elseif { [string index $pp 0] == "#" } {
  580.         return [C_prevCodeIndent [pos::math [lindex $p 0] - 1]]
  581.     } elseif { $pp == "*/" } {
  582.         return [C_prevCodeIndent [lindex \
  583.           [search -s -f 0 -r 0 "/*" [pos::math [lindex $p 0] - 1]] 0]]
  584.     } elseif { ![catch {set comment [C_inCComment [lindex $p 0]]} ] } {
  585.         return [C_prevCodeIndent [pos::math [lineStart [lindex $comment 0]] - 1]]
  586.         #return [text::indentation [lindex $comment 0]] (old style)
  587.     }
  588.     }
  589.     return $p
  590. }
  591.  
  592.  
  593. # ◊◊◊◊ Electric routines ◊◊◊◊ #
  594.  
  595. proc C::carriageReturn {} {C++::carriageReturn}
  596. proc C::OptionTitlebar {} {C++::OptionTitlebar}
  597. proc C::OptionTitlebarSelect {item} {C++::OptionTitlebarSelect $item}
  598.  
  599. ## 
  600.  # -------------------------------------------------------------------------
  601.  #     
  602.  # "C++::carriageReturn" --
  603.  #    
  604.  #    Called by the general routine 'carriageReturn'.    We know    no selection 
  605.  #    exists, and we are not inside a block comment.
  606.  # -------------------------------------------------------------------------
  607.  ##
  608. proc C++::carriageReturn {} {
  609.     if {[lookAt [pos::math [getPos] - 1]] == ":"} {
  610.     if { [lookAt [getPos]] == "\r" } {
  611.         bind::IndentLine
  612.         endOfLine
  613.         insertText "\r"
  614.     } else {
  615.         set pos [getPos]
  616.         endOfLine
  617.         set t [getText $pos [getPos]]
  618.         replaceText $pos [getPos] ""
  619.         bind::IndentLine
  620.         endOfLine
  621.         insertText "\r"
  622.         insertText $t
  623.     }
  624.     } else {
  625.     insertText "\r"
  626.     }
  627.     catch {bind::IndentLine}
  628. }
  629.  
  630. proc C++::OptionTitlebar {} {
  631.     if {![catch {C++::tryIDEget} ret] && ![regexp {\(No} $ret] } { return $ret }
  632.     # else just scan through, provided the scan will function
  633.     set cid [scancontext create]
  634.     set lines {}
  635.     scanmatch $cid {#.*include.*(<|")(.*)(>|")}  {lappend lines $matchInfo(submatch1)}
  636.     set fid [open [win::Current] "r"]
  637.     scanfile $cid $fid
  638.     close $fid
  639.     scancontext delete $cid
  640.     return [lsort -ignore $lines]
  641. }
  642.  
  643. proc C++::OptionTitlebarSelect {fname} {
  644.     C++::tryIDEedit $fname
  645. }
  646.  
  647. proc C++::tryIDEget {} {
  648.     global IDE
  649.     switch $IDE {
  650.       1 {thinkGetIncludeFiles}
  651.       0 {cw::getIncludeFiles}
  652.       2 {error "No IDE at all!"}
  653.   }
  654. }
  655.  
  656. proc C++::tryIDEedit {fname} {
  657.     global IDE
  658.     switch $IDE {
  659.         1 {thinkEditIncludeFile $fname}
  660.         0 {cw::editIncludeFile $fname}
  661.         2 {error "No IDE at all!"}
  662.     }
  663. }
  664.  
  665.  
  666.  
  667.  
  668.  
  669.  
  670.  
  671.  
  672.  
  673.